layui.define(["jquery"], function(exports) {
	var jQuery = layui.jquery;

	(function($) {

		/**
		 * fullPage 2.5.4
		 * https://github.com/alvarotrigo/fullPage.js
		 * MIT licensed
		 *
		 * Copyright (C) 2013 alvarotrigo.com - A project by Alvaro Trigo
		 */

		(function($) {
			$.fn.fullpage = function(options) {
				// Create some defaults, extending them with any options that were provided
				options = $.extend({
					//navigation
					'menu': false,
					'anchors': [],
					'navigation': false,
					'navigationPosition': 'right',
					'navigationColor': '#000',
					'navigationTooltips': [],
					'slidesNavigation': false,
					'slidesNavPosition': 'bottom',
					'scrollBar': false,

					//scrolling
					'css3': true,
					'scrollingSpeed': 700,
					'autoScrolling': true,
					'easing': 'easeInQuart',
					'easingcss3': 'ease',
					'loopBottom': false,
					'loopTop': false,
					'loopHorizontal': true,
					'continuousVertical': false,
					'normalScrollElements': null,
					'scrollOverflow': false,
					'touchSensitivity': 5,
					'normalScrollElementTouchThreshold': 5,

					//Accessibility
					'keyboardScrolling': true,
					'animateAnchor': true,
					'recordHistory': true,

					//design
					'controlArrows': true,
					'controlArrowColor': '#fff',
					"verticalCentered": true,
					'resize': true,
					'sectionsColor': [],
					'paddingTop': 0,
					'paddingBottom': 0,
					'fixedElements': null,
					'responsive': 0,

					//Custom selectors
					'sectionSelector': '.section',
					'slideSelector': '.slide',

					//events
					'afterLoad': null,
					'onLeave': null,
					'afterRender': null,
					'afterResize': null,
					'afterReBuild': null,
					'afterSlideLoad': null,
					'onSlideLeave': null
				}, options);

				displayWarnings();

				//easeInQuart animation included in the plugin
				$.extend($.easing, {
					easeInQuart: function(x, t, b, c, d) {
						return c * (t /= d) * t * t * t + b;
					}
				});

				//滚动停留时间,官方说明为了防止苹果本上的一些误差，不建议设置400以下，目前修改后没有出现异常 2019-07-22
				var scrollDelay = 0;

				$.fn.fullpage.setAutoScrolling = function(value, type) {
					setVariableState('autoScrolling', value, type);

					var element = $('.fp-section.active');

					if(options.autoScrolling && !options.scrollBar) {
						$('html, body').css({
							'overflow': 'hidden',
							'height': '100%'
						});

						$.fn.fullpage.setRecordHistory(options.recordHistory, 'internal');

						//for IE touch devices
						container.css({
							'-ms-touch-action': 'none',
							'touch-action': 'none'
						});

						if(element.length) {
							//moving the container up
							silentScroll(element.position().top);
						}

					} else {
						$('html, body').css({
							'overflow': 'visible',
							'height': 'initial'
						});

						$.fn.fullpage.setRecordHistory(false, 'internal');

						//for IE touch devices
						container.css({
							'-ms-touch-action': '',
							'touch-action': ''
						});

						silentScroll(0);

						//scrolling the page to the section with no animation
						$('html, body').scrollTop(element.position().top);
					}

				};

				/**
				 * Defines wheter to record the history for each hash change in the URL.
				 */
				$.fn.fullpage.setRecordHistory = function(value, type) {
					setVariableState('recordHistory', value, type);
				};

				/**
				 * Defines the scrolling speed
				 */
				$.fn.fullpage.setScrollingSpeed = function(value, type) {
					setVariableState('scrollingSpeed', value, type);
				};

				/**
				 * Adds or remove the possiblity of scrolling through sections by using the mouse wheel or the trackpad.
				 */
				$.fn.fullpage.setMouseWheelScrolling = function(value) {
					if(value) {
						addMouseWheelHandler();
					} else {
						removeMouseWheelHandler();
					}
				};

				/**
				 * Adds or remove the possiblity of scrolling through sections by using the mouse wheel/trackpad or touch gestures.
				 * Optionally a second parameter can be used to specify the direction for which the action will be applied.
				 *
				 * @param directions string containing the direction or directions separated by comma.
				 */
				$.fn.fullpage.setAllowScrolling = function(value, directions) {
					if(typeof directions != 'undefined') {
						directions = directions.replace(' ', '').split(',');
						$.each(directions, function(index, direction) {
							setIsScrollable(value, direction);
						});
					} else if(value) {
						$.fn.fullpage.setMouseWheelScrolling(true);
						addTouchHandler();
					} else {
						$.fn.fullpage.setMouseWheelScrolling(false);
						removeTouchHandler();
					}
				};

				/**
				 * Adds or remove the possiblity of scrolling through sections by using the keyboard arrow keys
				 */
				$.fn.fullpage.setKeyboardScrolling = function(value) {
					options.keyboardScrolling = value;
				};

				$.fn.fullpage.moveSectionUp = function() {
					var prev = $('.fp-section.active').prev('.fp-section');

					//looping to the bottom if there's no more sections above
					if(!prev.length && (options.loopTop || options.continuousVertical)) {
						prev = $('.fp-section').last();
					}

					if(prev.length) {
						scrollPage(prev, null, true);
					}
				};

				$.fn.fullpage.moveSectionDown = function() {
					var next = $('.fp-section.active').next('.fp-section');

					//looping to the top if there's no more sections below
					if(!next.length &&
						(options.loopBottom || options.continuousVertical)) {
						next = $('.fp-section').first();
					}

					if(next.length) {
						scrollPage(next, null, false);
					}
				};

				$.fn.fullpage.moveTo = function(section, slide) {
					var destiny = '';

					if(isNaN(section)) {
						destiny = $('[data-anchor="' + section + '"]');
					} else {
						destiny = $('.fp-section').eq((section - 1));
					}

					if(typeof slide !== 'undefined') {
						scrollPageAndSlide(section, slide);
					} else if(destiny.length > 0) {
						scrollPage(destiny);
					}
				};

				$.fn.fullpage.moveSlideRight = function() {
					moveSlide('next');
				};

				$.fn.fullpage.moveSlideLeft = function() {
					moveSlide('prev');
				};

				/**
				 * When resizing is finished, we adjust the slides sizes and positions
				 */
				$.fn.fullpage.reBuild = function(resizing) {
					isResizing = true;

					var windowsWidth = $(window).width();
					windowsHeight = $(window).height(); //updating global var

					//text and images resizing
					if(options.resize) {
						resizeMe(windowsHeight, windowsWidth);
					}

					$('.fp-section').each(function() {
						var scrollHeight = windowsHeight - parseInt($(this).css('padding-bottom')) - parseInt($(this).css('padding-top'));

						//adjusting the height of the table-cell for IE and Firefox
						if(options.verticalCentered) {
							$(this).find('.fp-tableCell').css('height', getTableHeight($(this)) + 'px');
						}

						$(this).css('height', windowsHeight + 'px');

						//resizing the scrolling divs
						if(options.scrollOverflow) {
							var slides = $(this).find('.fp-slide');

							if(slides.length) {
								slides.each(function() {
									createSlimScrolling($(this));
								});
							} else {
								createSlimScrolling($(this));
							}
						}

						//adjusting the position fo the FULL WIDTH slides...
						var slides = $(this).find('.fp-slides');
						if(slides.length) {
							landscapeScroll(slides, slides.find('.fp-slide.active'));
						}
					});

					//adjusting the position for the current section
					var destinyPos = $('.fp-section.active').position();

					var activeSection = $('.fp-section.active');

					//isn't it the first section?
					if(activeSection.index('.fp-section')) {
						scrollPage(activeSection);
					}

					isResizing = false;
					$.isFunction(options.afterResize) && resizing && options.afterResize.call(this)
					$.isFunction(options.afterReBuild) && !resizing && options.afterReBuild.call(this);
				}

				//flag to avoid very fast sliding for landscape sliders
				var slideMoving = false;

				var isTouchDevice = navigator.userAgent.match(/(iPhone|iPod|iPad|Android|BlackBerry|BB10|Windows Phone|Tizen|Bada)/);
				var isTouch = (('ontouchstart' in window) || (navigator.msMaxTouchPoints > 0) || (navigator.maxTouchPoints));
				var container = $(this);
				var windowsHeight = $(window).height();
				var isMoving = false;
				var isResizing = false;
				var lastScrolledDestiny;
				var lastScrolledSlide;
				var nav;
				var wrapperSelector = 'fullpage-wrapper';
				var isScrollAllowed = {
					'up': true,
					'down': true,
					'left': true,
					'right': true
				};
				var originals = jQuery.extend(true, {}, options); //deep copy

				$.fn.fullpage.setAllowScrolling(true);

				//if css3 is not supported, it will use jQuery animations
				if(options.css3) {
					options.css3 = support3d();
				}

				if($(this).length) {
					container.css({
						'height': '100%',
						'position': 'relative'
					});

					//adding a class to recognize the container internally in the code
					container.addClass(wrapperSelector);
				}

				//trying to use fullpage without a selector?
				else {
					showError('error', "Error! Fullpage.js needs to be initialized with a selector. For example: $('#myContainer').fullpage();");
				}

				//adding internal class names to void problem with common ones
				$(options.sectionSelector).each(function() {
					$(this).addClass('fp-section');
				});
				$(options.slideSelector).each(function() {
					$(this).addClass('fp-slide');
				});

				//creating the navigation dots
				if(options.navigation) {
					addVerticalNavigation();
				}

				$('.fp-section').each(function(index) {
					var that = $(this);
					var slides = $(this).find('.fp-slide');
					var numSlides = slides.length;

					//if no active section is defined, the 1st one will be the default one
					if(!index && $('.fp-section.active').length === 0) {
						$(this).addClass('active');
					}

					$(this).css('height', windowsHeight + 'px');

					if(options.paddingTop || options.paddingBottom) {
						$(this).css('padding', options.paddingTop + ' 0 ' + options.paddingBottom + ' 0');
					}

					if(typeof options.sectionsColor[index] !== 'undefined') {
						$(this).css('background-color', options.sectionsColor[index]);
					}

					if(typeof options.anchors[index] !== 'undefined') {
						$(this).attr('data-anchor', options.anchors[index]);
					}

					// if there's any slide
					if(numSlides > 1) {
						var sliderWidth = numSlides * 100;
						var slideWidth = 100 / numSlides;

						slides.wrapAll('<div class="fp-slidesContainer" />');
						slides.parent().wrap('<div class="fp-slides" />');

						$(this).find('.fp-slidesContainer').css('width', sliderWidth + '%');

						if(options.controlArrows) {
							createSlideArrows($(this));
						}

						if(options.slidesNavigation) {
							addSlidesNavigation($(this), numSlides);
						}

						slides.each(function(index) {
							$(this).css('width', slideWidth + '%');

							if(options.verticalCentered) {
								addTableClass($(this));
							}
						});

						var startingSlide = that.find('.fp-slide.active');

						//if the slide won#t be an starting point, the default will be the first one
						if(startingSlide.length == 0) {
							slides.eq(0).addClass('active');
						}

						//is there a starting point for a non-starting section?
						else {
							silentLandscapeScroll(startingSlide);
						}

					} else {
						if(options.verticalCentered) {
							addTableClass($(this));
						}
					}

				}).promise().done(function() {
					$.fn.fullpage.setAutoScrolling(options.autoScrolling, 'internal');

					//the starting point is a slide?
					var activeSlide = $('.fp-section.active').find('.fp-slide.active');

					//the active section isn't the first one? Is not the first slide of the first section? Then we load that section/slide by default.
					if(activeSlide.length && ($('.fp-section.active').index('.fp-section') != 0 || ($('.fp-section.active').index('.fp-section') == 0 && activeSlide.index() != 0))) {
						silentLandscapeScroll(activeSlide);
					}

					//fixed elements need to be moved out of the plugin container due to problems with CSS3.
					if(options.fixedElements && options.css3) {
						$(options.fixedElements).appendTo('body');
					}

					//vertical centered of the navigation + first bullet active
					if(options.navigation) {
						nav.css('margin-top', '-' + (nav.height() / 2) + 'px');
						nav.find('li').eq($('.fp-section.active').index('.fp-section')).find('a').addClass('active');
					}

					//moving the menu outside the main container if it is inside (avoid problems with fixed positions when using CSS3 tranforms)
					if(options.menu && options.css3 && $(options.menu).closest('.fullpage-wrapper').length) {
						$(options.menu).appendTo('body');
					}

					if(options.scrollOverflow) {
						if(document.readyState === "complete") {
							createSlimScrollingHandler();
						}
						//after DOM and images are loaded
						$(window).on('load', createSlimScrollingHandler);
					} else {
						$.isFunction(options.afterRender) && options.afterRender.call(this);
					}

					responsive();

					//getting the anchor link in the URL and deleting the `#`
					var value = window.location.hash.replace('#', '').split('/');
					var destiny = value[0];

					if(destiny.length) {
						var section = $('[data-anchor="' + destiny + '"]');

						if(!options.animateAnchor && section.length) {

							if(options.autoScrolling) {
								silentScroll(section.position().top);
							} else {
								silentScroll(0);
								setBodyClass(destiny);

								//scrolling the page to the section with no animation
								$('html, body').scrollTop(section.position().top);
							}

							activateMenuAndNav(destiny, null);

							$.isFunction(options.afterLoad) && options.afterLoad.call(this, destiny, (section.index('.fp-section') + 1));

							//updating the active class
							section.addClass('active').siblings().removeClass('active');
						}
					}

					$(window).on('load', function() {
						scrollToAnchor();
					});

				});

				/**
				 * Creates the control arrows for the given section
				 */
				function createSlideArrows(section) {
					section.find('.fp-slides').after('<div class="fp-controlArrow fp-prev"></div><div class="fp-controlArrow fp-next"></div>');

					if(options.controlArrowColor != '#fff') {
						section.find('.fp-controlArrow.fp-next').css('border-color', 'transparent transparent transparent ' + options.controlArrowColor);
						section.find('.fp-controlArrow.fp-prev').css('border-color', 'transparent ' + options.controlArrowColor + ' transparent transparent');
					}

					if(!options.loopHorizontal) {
						section.find('.fp-controlArrow.fp-prev').hide();
					}
				}

				/**
				 * Creates a vertical navigation bar.
				 */
				function addVerticalNavigation() {
					$('body').append('<div id="fp-nav"><ul></ul></div>');
					nav = $('#fp-nav');

					nav.css('color', options.navigationColor);
					nav.addClass(options.navigationPosition);

					for(var i = 0; i < $('.fp-section').length; i++) {
						var link = '';
						if(options.anchors.length) {
							link = options.anchors[i];
						}

						var li = '<li><a href="#' + link + '"><span></span></a>';

						// Only add tooltip if needed (defined by user)
						var tooltip = options.navigationTooltips[i];
						if(tooltip != undefined && tooltip != '') {
							li += '<div class="fp-tooltip ' + options.navigationPosition + '">' + tooltip + '</div>';
						}

						li += '</li>';

						nav.find('ul').append(li);
					}
				}

				function createSlimScrollingHandler() {
					$('.fp-section').each(function() {
						var slides = $(this).find('.fp-slide');

						if(slides.length) {
							slides.each(function() {
								createSlimScrolling($(this));
							});
						} else {
							createSlimScrolling($(this));
						}

					});
					$.isFunction(options.afterRender) && options.afterRender.call(this);
				}

				var scrollId;
				var scrollId2;
				var isScrolling = false;

				//when scrolling...
				$(window).on('scroll', scrollHandler);

				function scrollHandler() {
					if(!options.autoScrolling || options.scrollBar) {
						var currentScroll = $(window).scrollTop();
						var visibleSectionIndex = 0;
						var initial = Math.abs(currentScroll - $('.fp-section').first().offset().top);

						//taking the section which is showing more content in the viewport
						$('.fp-section').each(function(index) {
							var current = Math.abs(currentScroll - $(this).offset().top);

							if(current < initial) {
								visibleSectionIndex = index;
								initial = current;
							}
						});

						//geting the last one, the current one on the screen
						var currentSection = $('.fp-section').eq(visibleSectionIndex);
					}

					if(!options.autoScrolling) {
						//executing only once the first time we reach the section
						if(!currentSection.hasClass('active')) {
							isScrolling = true;

							var leavingSection = $('.fp-section.active').index('.fp-section') + 1;
							var yMovement = getYmovement(currentSection);
							var anchorLink = currentSection.data('anchor');
							var sectionIndex = currentSection.index('.fp-section') + 1;
							var activeSlide = currentSection.find('.fp-slide.active');

							if(activeSlide.length) {
								var slideAnchorLink = activeSlide.data('anchor');
								var slideIndex = activeSlide.index();
							}

							currentSection.addClass('active').siblings().removeClass('active');

							if(!isMoving) {
								$.isFunction(options.onLeave) && options.onLeave.call(this, leavingSection, sectionIndex, yMovement);

								$.isFunction(options.afterLoad) && options.afterLoad.call(this, anchorLink, sectionIndex);
							}

							activateMenuAndNav(anchorLink, 0);

							if(options.anchors.length && !isMoving) {
								//needed to enter in hashChange event when using the menu with anchor links
								lastScrolledDestiny = anchorLink;

								setState(slideIndex, slideAnchorLink, anchorLink, sectionIndex);
							}

							//small timeout in order to avoid entering in hashChange event when scrolling is not finished yet
							clearTimeout(scrollId);
							scrollId = setTimeout(function() {
								isScrolling = false;
							}, 100);
						}
					}

					if(options.scrollBar) {
						//for the auto adjust of the viewport to fit a whole section
						clearTimeout(scrollId2);
						scrollId2 = setTimeout(function() {
							if(!isMoving) {
								scrollPage(currentSection);
							}
						}, 1000);
					}
				}

				/**
				 * Determines whether the active section or slide is scrollable through and scrolling bar
				 */
				function isScrollable(activeSection) {
					//if there are landscape slides, we check if the scrolling bar is in the current one or not
					if(activeSection.find('.fp-slides').length) {
						scrollable = activeSection.find('.fp-slide.active').find('.fp-scrollable');
					} else {
						scrollable = activeSection.find('.fp-scrollable');
					}

					return scrollable;
				}

				/**
				 * Determines the way of scrolling up or down:
				 * by 'automatically' scrolling a section or by using the default and normal scrolling.
				 */
				function scrolling(type, scrollable) {
					if(!isScrollAllowed[type]) {
						return;
					}

					if(type == 'down') {
						var check = 'bottom';
						var scrollSection = $.fn.fullpage.moveSectionDown;
					} else {
						var check = 'top';
						var scrollSection = $.fn.fullpage.moveSectionUp;
					}

					if(scrollable.length > 0) {
						//is the scrollbar at the start/end of the scroll?
						if(isScrolled(check, scrollable)) {
							scrollSection();
						} else {
							return true;
						}
					} else {
						// moved up/down
						scrollSection();
					}
				}

				var touchStartY = 0;
				var touchStartX = 0;
				var touchEndY = 0;
				var touchEndX = 0;

				/* Detecting touch events

				* As we are changing the top property of the page on scrolling, we can not use the traditional way to detect it.
				* This way, the touchstart and the touch moves shows an small difference between them which is the
				* used one to determine the direction.
				*/
				function touchMoveHandler(event) {
					var e = event.originalEvent;

					// additional: if one of the normalScrollElements isn't within options.normalScrollElementTouchThreshold hops up the DOM chain
					if(!checkParentForNormalScrollElement(event.target)) {

						if(options.autoScrolling && !options.scrollBar) {
							//preventing the easing on iOS devices
							event.preventDefault();
						}

						var activeSection = $('.fp-section.active');
						var scrollable = isScrollable(activeSection);

						if(!isMoving && !slideMoving) { //if theres any #
							var touchEvents = getEventsPage(e);

							touchEndY = touchEvents['y'];
							touchEndX = touchEvents['x'];

							//if movement in the X axys is greater than in the Y and the currect section has slides...
							if(activeSection.find('.fp-slides').length && Math.abs(touchStartX - touchEndX) > (Math.abs(touchStartY - touchEndY))) {

								//is the movement greater than the minimum resistance to scroll?
								if(Math.abs(touchStartX - touchEndX) > ($(window).width() / 100 * options.touchSensitivity)) {
									if(touchStartX > touchEndX) {
										if(isScrollAllowed.right) {
											$.fn.fullpage.moveSlideRight(); //next
										}
									} else {
										if(isScrollAllowed.left) {
											$.fn.fullpage.moveSlideLeft(); //prev
										}
									}
								}
							}

							//vertical scrolling (only when autoScrolling is enabled)
							else if(options.autoScrolling && !options.scrollBar) {

								//is the movement greater than the minimum resistance to scroll?
								if(Math.abs(touchStartY - touchEndY) > ($(window).height() / 100 * options.touchSensitivity)) {
									if(touchStartY > touchEndY) {
										scrolling('down', scrollable);
									} else if(touchEndY > touchStartY) {
										scrolling('up', scrollable);
									}
								}
							}
						}
					}

				}

				/**
				 * recursive function to loop up the parent nodes to check if one of them exists in options.normalScrollElements
				 * Currently works well for iOS - Android might need some testing
				 * @param  {Element} el  target element / jquery selector (in subsequent nodes)
				 * @param  {int}     hop current hop compared to options.normalScrollElementTouchThreshold
				 * @return {boolean} true if there is a match to options.normalScrollElements
				 */
				function checkParentForNormalScrollElement(el, hop) {
					hop = hop || 0;
					var parent = $(el).parent();

					if(hop < options.normalScrollElementTouchThreshold &&
						parent.is(options.normalScrollElements)) {
						return true;
					} else if(hop == options.normalScrollElementTouchThreshold) {
						return false;
					} else {
						return checkParentForNormalScrollElement(parent, ++hop);
					}
				}

				function touchStartHandler(event) {
					var e = event.originalEvent;

					var touchEvents = getEventsPage(e);
					touchStartY = touchEvents['y'];
					touchStartX = touchEvents['x'];
				}

				/**
				 * Detecting mousewheel scrolling
				 *
				 * http://blogs.sitepointstatic.com/examples/tech/mouse-wheel/index.html
				 * http://www.sitepoint.com/html5-javascript-mouse-wheel/
				 */
				function MouseWheelHandler(e) {
					if(options.autoScrolling) {
						// cross-browser wheel delta
						e = window.event || e;
						var delta = Math.max(-1, Math.min(1,
							(e.wheelDelta || -e.deltaY || -e.detail)));

						//preventing to scroll the site on mouse wheel when scrollbar is present
						if(options.scrollBar) {
							e.preventDefault ? e.preventDefault() : e.returnValue = false;

						}

						var activeSection = $('.fp-section.active');
						var scrollable = isScrollable(activeSection);

						if(!isMoving) { //if theres any #
							//scrolling down?
							if(delta < 0) {
								scrolling('down', scrollable);

								//scrolling up?
							} else {
								scrolling('up', scrollable);
							}
						}

						return false;
					}
				}

				function moveSlide(direction) {
					var activeSection = $('.fp-section.active');
					var slides = activeSection.find('.fp-slides');

					// more than one slide needed and nothing should be sliding
					if(!slides.length || slideMoving) {
						return;
					}

					var currentSlide = slides.find('.fp-slide.active');
					var destiny = null;

					if(direction === 'prev') {
						destiny = currentSlide.prev('.fp-slide');
					} else {
						destiny = currentSlide.next('.fp-slide');
					}

					//isn't there a next slide in the secuence?
					if(!destiny.length) {
						//respect loopHorizontal settin
						if(!options.loopHorizontal) return;

						if(direction === 'prev') {
							destiny = currentSlide.siblings(':last');
						} else {
							destiny = currentSlide.siblings(':first');
						}
					}

					slideMoving = true;

					landscapeScroll(slides, destiny);
				}

				/**
				 * Maintains the active slides in the viewport
				 * (Because he `scroll` animation might get lost with some actions, such as when using continuousVertical)
				 */
				function keepSlidesPosition() {
					$('.fp-slide.active').each(function() {
						silentLandscapeScroll($(this));
					});
				}

				/**
				 * Scrolls the site to the given element and scrolls to the slide if a callback is given.
				 */
				function scrollPage(element, callback, isMovementUp) {
					var dest = element.position();
					if(typeof dest === "undefined") {
						return;
					} //there's no element to scroll, leaving the function

					//local variables
					var v = {
						element: element,
						callback: callback,
						isMovementUp: isMovementUp,
						dest: dest,
						dtop: dest.top,
						yMovement: getYmovement(element),
						anchorLink: element.data('anchor'),
						sectionIndex: element.index('.fp-section'),
						activeSlide: element.find('.fp-slide.active'),
						activeSection: $('.fp-section.active'),
						leavingSection: $('.fp-section.active').index('.fp-section') + 1,

						//caching the value of isResizing at the momment the function is called
						//because it will be checked later inside a setTimeout and the value might change
						localIsResizing: isResizing
					};

					//quiting when destination scroll is the same as the current one
					if((v.activeSection.is(element) && !isResizing) || (options.scrollBar && $(window).scrollTop() === v.dtop)) {
						return;
					}

					if(v.activeSlide.length) {
						var slideAnchorLink = v.activeSlide.data('anchor');
						var slideIndex = v.activeSlide.index();
					}

					// If continuousVertical && we need to wrap around
					if(options.autoScrolling && options.continuousVertical && typeof(v.isMovementUp) !== "undefined" &&
						((!v.isMovementUp && v.yMovement == 'up') || // Intending to scroll down but about to go up or
							(v.isMovementUp && v.yMovement == 'down'))) { // intending to scroll up but about to go down

						v = createInfiniteSections(v);
					}

					element.addClass('active').siblings().removeClass('active');

					//preventing from activating the MouseWheelHandler event
					//more than once if the page is scrolling
					isMoving = true;

					setState(slideIndex, slideAnchorLink, v.anchorLink, v.sectionIndex);

					//callback (onLeave) if the site is not just resizing and readjusting the slides
					$.isFunction(options.onLeave) && !v.localIsResizing && options.onLeave.call(this, v.leavingSection, (v.sectionIndex + 1), v.yMovement);

					performMovement(v);

					//flag to avoid callingn `scrollPage()` twice in case of using anchor links
					lastScrolledDestiny = v.anchorLink;

					//avoid firing it twice (as it does also on scroll)
					if(options.autoScrolling) {
						activateMenuAndNav(v.anchorLink, v.sectionIndex)
					}
				}

				/**
				 * Performs the movement (by CSS3 or by jQuery)
				 */
				function performMovement(v) {
					// using CSS3 translate functionality
					if(options.css3 && options.autoScrolling && !options.scrollBar) {

						var translate3d = 'translate3d(0px, -' + v.dtop + 'px, 0px)';
						transformContainer(translate3d, true);

						setTimeout(function() {
							afterSectionLoads(v);
						}, options.scrollingSpeed);
					}

					// using jQuery animate
					else {
						var scrollSettings = getScrollSettings(v);

						$(scrollSettings.element).animate(
							scrollSettings.options, options.scrollingSpeed, options.easing).promise().done(function() { //only one single callback in case of animating  `html, body`
							afterSectionLoads(v);
						});
					}
				}

				/**
				 * Gets the scrolling settings depending on the plugin autoScrolling option
				 */
				function getScrollSettings(v) {
					var scroll = {};

					if(options.autoScrolling && !options.scrollBar) {
						scroll.options = {
							'top': -v.dtop
						};
						scroll.element = '.' + wrapperSelector;
					} else {
						scroll.options = {
							'scrollTop': v.dtop
						};
						scroll.element = 'html, body';
					}

					return scroll;
				}

				/**
				 * Adds sections before or after the current one to create the infinite effect.
				 */
				function createInfiniteSections(v) {
					// Scrolling down
					if(!v.isMovementUp) {
						// Move all previous sections to after the active section
						$(".fp-section.active").after(v.activeSection.prevAll(".fp-section").get().reverse());
					} else { // Scrolling up
						// Move all next sections to before the active section
						$(".fp-section.active").before(v.activeSection.nextAll(".fp-section"));
					}

					// Maintain the displayed position (now that we changed the element order)
					silentScroll($('.fp-section.active').position().top);

					// Maintain the active slides visible in the viewport
					keepSlidesPosition();

					// save for later the elements that still need to be reordered
					v.wrapAroundElements = v.activeSection;

					// Recalculate animation variables
					v.dest = v.element.position();
					v.dtop = v.dest.top;
					v.yMovement = getYmovement(v.element);

					return v;
				}

				/**
				 * Fix section order after continuousVertical changes have been animated
				 */
				function continuousVerticalFixSectionOrder(v) {
					// If continuousVertical is in effect (and autoScrolling would also be in effect then),
					// finish moving the elements around so the direct navigation will function more simply
					if(!v.wrapAroundElements || !v.wrapAroundElements.length) {
						return;
					}

					if(v.isMovementUp) {
						$('.fp-section:first').before(v.wrapAroundElements);
					} else {
						$('.fp-section:last').after(v.wrapAroundElements);
					}

					silentScroll($('.fp-section.active').position().top);

					// Maintain the active slides visible in the viewport
					keepSlidesPosition();
				};

				/**
				 * Actions to do once the section is loaded
				 */
				function afterSectionLoads(v) {
					continuousVerticalFixSectionOrder(v);
					//callback (afterLoad) if the site is not just resizing and readjusting the slides
					$.isFunction(options.afterLoad) && !v.localIsResizing && options.afterLoad.call(this, v.anchorLink, (v.sectionIndex + 1));

					setTimeout(function() {
						isMoving = false;
						$.isFunction(v.callback) && v.callback.call(this);
					}, scrollDelay);
				}

				/**
				 * Scrolls to the anchor in the URL when loading the site
				 */
				function scrollToAnchor() {
					//getting the anchor link in the URL and deleting the `#`
					var value = window.location.hash.replace('#', '').split('/');
					var section = value[0];
					var slide = value[1];

					if(section) { //if theres any #
						scrollPageAndSlide(section, slide);
					}
				}

				//detecting any change on the URL to scroll to the given anchor link
				//(a way to detect back history button as we play with the hashes on the URL)
				$(window).on('hashchange', hashChangeHandler);

				function hashChangeHandler() {
					if(!isScrolling) {
						var value = window.location.hash.replace('#', '').split('/');
						var section = value[0];
						var slide = value[1];

						if(section.length) {
							//when moving to a slide in the first section for the first time (first time to add an anchor to the URL)
							var isFirstSlideMove = (typeof lastScrolledDestiny === 'undefined');
							var isFirstScrollMove = (typeof lastScrolledDestiny === 'undefined' && typeof slide === 'undefined' && !slideMoving);

							/*in order to call scrollpage() only once for each destination at a time
							It is called twice for each scroll otherwise, as in case of using anchorlinks `hashChange`
							event is fired on every scroll too.*/
							if((section && section !== lastScrolledDestiny) && !isFirstSlideMove || isFirstScrollMove || (!slideMoving && lastScrolledSlide != slide)) {
								scrollPageAndSlide(section, slide);
							}
						}
					}
				}

				/**
				 * Sliding with arrow keys, both, vertical and horizontal
				 */
				$(document).keydown(function(e) {
					//Moving the main page with the keyboard arrows if keyboard scrolling is enabled
					if(options.keyboardScrolling && options.autoScrolling) {

						//preventing the scroll with arrow keys
						if(e.which == 40 || e.which == 38) {
							e.preventDefault();
						}

						if(!isMoving) {
							switch(e.which) {
								//up
								case 38:
								case 33:
									$.fn.fullpage.moveSectionUp();
									break;

									//down
								case 40:
								case 34:
									$.fn.fullpage.moveSectionDown();
									break;

									//Home
								case 36:
									$.fn.fullpage.moveTo(1);
									break;

									//End
								case 35:
									$.fn.fullpage.moveTo($('.fp-section').length);
									break;

									//left
								case 37:
									$.fn.fullpage.moveSlideLeft();
									break;

									//right
								case 39:
									$.fn.fullpage.moveSlideRight();
									break;

								default:
									return; // exit this handler for other keys
							}
						}
					}
				});

				/**
				 * Scrolls to the section when clicking the navigation bullet
				 */
				$(document).on('click touchstart', '#fp-nav a', function(e) {
					e.preventDefault();
					var index = $(this).parent().index();
					scrollPage($('.fp-section').eq(index));
				});

				/**
				 * Scrolls the slider to the given slide destination for the given section
				 */
				$(document).on('click touchstart', '.fp-slidesNav a', function(e) {
					e.preventDefault();
					var slides = $(this).closest('.fp-section').find('.fp-slides');
					var destiny = slides.find('.fp-slide').eq($(this).closest('li').index());

					landscapeScroll(slides, destiny);
				});

				if(options.normalScrollElements) {
					$(document).on('mouseenter', options.normalScrollElements, function() {
						$.fn.fullpage.setMouseWheelScrolling(false);
					});

					$(document).on('mouseleave', options.normalScrollElements, function() {
						$.fn.fullpage.setMouseWheelScrolling(true);
					});
				}

				/**
				 * Scrolling horizontally when clicking on the slider controls.
				 */
				$('.fp-section').on('click touchstart', '.fp-controlArrow', function() {
					if($(this).hasClass('fp-prev')) {
						$.fn.fullpage.moveSlideLeft();
					} else {
						$.fn.fullpage.moveSlideRight();
					}
				});

				/**
				 * Scrolls horizontal sliders.
				 */
				function landscapeScroll(slides, destiny) {
					var destinyPos = destiny.position();
					var slidesContainer = slides.find('.fp-slidesContainer').parent();
					var slideIndex = destiny.index();
					var section = slides.closest('.fp-section');
					var sectionIndex = section.index('.fp-section');
					var anchorLink = section.data('anchor');
					var slidesNav = section.find('.fp-slidesNav');
					var slideAnchor = destiny.data('anchor');

					//caching the value of isResizing at the momment the function is called
					//because it will be checked later inside a setTimeout and the value might change
					var localIsResizing = isResizing;

					if(options.onSlideLeave) {
						var prevSlideIndex = section.find('.fp-slide.active').index();
						var xMovement = getXmovement(prevSlideIndex, slideIndex);

						//if the site is not just resizing and readjusting the slides
						if(!localIsResizing && xMovement !== 'none') {
							$.isFunction(options.onSlideLeave) && options.onSlideLeave.call(this, anchorLink, (sectionIndex + 1), prevSlideIndex, xMovement);
						}
					}

					destiny.addClass('active').siblings().removeClass('active');

					if(typeof slideAnchor === 'undefined') {
						slideAnchor = slideIndex;
					}

					if(!options.loopHorizontal && options.controlArrows) {
						//hidding it for the fist slide, showing for the rest
						section.find('.fp-controlArrow.fp-prev').toggle(slideIndex != 0);

						//hidding it for the last slide, showing for the rest
						section.find('.fp-controlArrow.fp-next').toggle(!destiny.is(':last-child'));
					}

					//only changing the URL if the slides are in the current section (not for resize re-adjusting)
					if(section.hasClass('active')) {
						setState(slideIndex, slideAnchor, anchorLink, sectionIndex);
					}

					var afterSlideLoads = function() {
						//if the site is not just resizing and readjusting the slides
						if(!localIsResizing) {
							$.isFunction(options.afterSlideLoad) && options.afterSlideLoad.call(this, anchorLink, (sectionIndex + 1), slideAnchor, slideIndex);
						}
						//letting them slide again
						slideMoving = false;
					};

					if(options.css3) {
						var translate3d = 'translate3d(-' + destinyPos.left + 'px, 0px, 0px)';

						addAnimation(slides.find('.fp-slidesContainer'), options.scrollingSpeed > 0).css(getTransforms(translate3d));

						setTimeout(function() {
							afterSlideLoads();
						}, options.scrollingSpeed, options.easing);
					} else {
						slidesContainer.animate({
							scrollLeft: destinyPos.left
						}, options.scrollingSpeed, options.easing, function() {

							afterSlideLoads();
						});
					}

					slidesNav.find('.active').removeClass('active');
					slidesNav.find('li').eq(slideIndex).find('a').addClass('active');
				}

				//when resizing the site, we adjust the heights of the sections, slimScroll...
				$(window).resize(resizeHandler);

				var previousHeight = windowsHeight;
				var resizeId;

				function resizeHandler() {
					//checking if it needs to get responsive
					responsive();

					// rebuild immediately on touch devices
					if(isTouchDevice) {

						//if the keyboard is visible
						if($(document.activeElement).attr('type') !== 'text') {
							var currentHeight = $(window).height();

							//making sure the change in the viewport size is enough to force a rebuild. (20 % of the window to avoid problems when hidding scroll bars)
							if(Math.abs(currentHeight - previousHeight) > (20 * Math.max(previousHeight, currentHeight) / 100)) {
								$.fn.fullpage.reBuild(true);
								previousHeight = currentHeight;
							}
						}
					} else {
						//in order to call the functions only when the resize is finished
						//http://stackoverflow.com/questions/4298612/jquery-how-to-call-resize-event-only-once-its-finished-resizing
						clearTimeout(resizeId);

						resizeId = setTimeout(function() {
							$.fn.fullpage.reBuild(true);
						}, 500);
					}
				}

				/**
				 * Checks if the site needs to get responsive and disables autoScrolling if so.
				 * A class `fp-responsive` is added to the plugin's container in case the user wants to use it for his own responsive CSS.
				 */
				function responsive() {
					if(options.responsive) {
						var isResponsive = container.hasClass('fp-responsive');
						if($(window).width() < options.responsive) {
							if(!isResponsive) {
								$.fn.fullpage.setAutoScrolling(false, 'internal');
								$('#fp-nav').hide();
								container.addClass('fp-responsive');
							}
						} else if(isResponsive) {
							$.fn.fullpage.setAutoScrolling(originals.autoScrolling, 'internal');
							$('#fp-nav').show();
							container.removeClass('fp-responsive');
						}
					}
				}

				/**
				 * Adds transition animations for the given element
				 */
				function addAnimation(element) {
					var transition = 'all ' + options.scrollingSpeed + 'ms ' + options.easingcss3;

					element.removeClass('fp-notransition');
					return element.css({
						'-webkit-transition': transition,
						'transition': transition
					});
				}

				/**
				 * Remove transition animations for the given element
				 */
				function removeAnimation(element) {
					return element.addClass('fp-notransition');
				}

				/**
				 * Resizing of the font size depending on the window size as well as some of the images on the site.
				 */
				function resizeMe(displayHeight, displayWidth) {
					//Standard dimensions, for which the body font size is correct
					var preferredHeight = 825;
					var preferredWidth = 900;

					if(displayHeight < preferredHeight || displayWidth < preferredWidth) {
						var heightPercentage = (displayHeight * 100) / preferredHeight;
						var widthPercentage = (displayWidth * 100) / preferredWidth;
						var percentage = Math.min(heightPercentage, widthPercentage);
						var newFontSize = percentage.toFixed(2);

						$("body").css("font-size", newFontSize + '%');
					} else {
						$("body").css("font-size", '100%');
					}
				}

				/**
				 * Activating the website navigation dots according to the given slide name.
				 */
				function activateNavDots(name, sectionIndex) {
					if(options.navigation) {
						$('#fp-nav').find('.active').removeClass('active');
						if(name) {
							$('#fp-nav').find('a[href="#' + name + '"]').addClass('active');
						} else {
							$('#fp-nav').find('li').eq(sectionIndex).find('a').addClass('active');
						}
					}
				}

				/**
				 * Activating the website main menu elements according to the given slide name.
				 */
				function activateMenuElement(name) {
					if(options.menu) {
						$(options.menu).find('.active').removeClass('active');
						$(options.menu).find('[data-menuanchor="' + name + '"]').addClass('active');
					}
				}

				function activateMenuAndNav(anchor, index) {
					activateMenuElement(anchor);
					activateNavDots(anchor, index);
				}

				/**
				 * Return a boolean depending on whether the scrollable element is at the end or at the start of the scrolling
				 * depending on the given type.
				 */
				function isScrolled(type, scrollable) {
					if(type === 'top') {
						return !scrollable.scrollTop();
					} else if(type === 'bottom') {
						return scrollable.scrollTop() + 1 + scrollable.innerHeight() >= scrollable[0].scrollHeight;
					}
				}

				/**
				 * Retuns `up` or `down` depending on the scrolling movement to reach its destination
				 * from the current section.
				 */
				function getYmovement(destiny) {
					var fromIndex = $('.fp-section.active').index('.fp-section');
					var toIndex = destiny.index('.fp-section');
					if(fromIndex == toIndex) {
						return 'none'
					}
					if(fromIndex > toIndex) {
						return 'up';
					}
					return 'down';
				}

				/**
				 * Retuns `right` or `left` depending on the scrolling movement to reach its destination
				 * from the current slide.
				 */
				function getXmovement(fromIndex, toIndex) {
					if(fromIndex == toIndex) {
						return 'none'
					}
					if(fromIndex > toIndex) {
						return 'left';
					}
					return 'right';
				}

				function createSlimScrolling(element) {
					//needed to make `scrollHeight` work under Opera 12
					element.css('overflow', 'hidden');

					//in case element is a slide
					var section = element.closest('.fp-section');
					var scrollable = element.find('.fp-scrollable');

					//if there was scroll, the contentHeight will be the one in the scrollable section
					if(scrollable.length) {
						var contentHeight = scrollable.get(0).scrollHeight;
					} else {
						var contentHeight = element.get(0).scrollHeight;
						if(options.verticalCentered) {
							contentHeight = element.find('.fp-tableCell').get(0).scrollHeight;
						}
					}

					var scrollHeight = windowsHeight - parseInt(section.css('padding-bottom')) - parseInt(section.css('padding-top'));

					//needs scroll?
					if(contentHeight > scrollHeight) {
						//was there already an scroll ? Updating it
						if(scrollable.length) {
							scrollable.css('height', scrollHeight + 'px').parent().css('height', scrollHeight + 'px');
						}
						//creating the scrolling
						else {
							if(options.verticalCentered) {
								element.find('.fp-tableCell').wrapInner('<div class="fp-scrollable" />');
							} else {
								element.wrapInner('<div class="fp-scrollable" />');
							}

							element.find('.fp-scrollable').slimScroll({
								allowPageScroll: true,
								height: scrollHeight + 'px',
								size: '10px',
								alwaysVisible: true
							});
						}
					}

					//removing the scrolling when it is not necessary anymore
					else {
						removeSlimScroll(element);
					}

					//undo
					element.css('overflow', '');
				}

				function removeSlimScroll(element) {
					element.find('.fp-scrollable').children().first().unwrap().unwrap();
					element.find('.slimScrollBar').remove();
					element.find('.slimScrollRail').remove();
				}

				function addTableClass(element) {
					element.addClass('fp-table').wrapInner('<div class="fp-tableCell" style="height:' + getTableHeight(element) + 'px;" />');
				}

				function getTableHeight(element) {
					var sectionHeight = windowsHeight;

					if(options.paddingTop || options.paddingBottom) {
						var section = element;
						if(!section.hasClass('fp-section')) {
							section = element.closest('.fp-section');
						}

						var paddings = parseInt(section.css('padding-top')) + parseInt(section.css('padding-bottom'));
						sectionHeight = (windowsHeight - paddings);
					}

					return sectionHeight;
				}

				/**
				 * Adds a css3 transform property to the container class with or without animation depending on the animated param.
				 */
				function transformContainer(translate3d, animated) {
					if(animated) {
						addAnimation(container);
					} else {
						removeAnimation(container);
					}

					container.css(getTransforms(translate3d));

					//syncronously removing the class after the animation has been applied.
					setTimeout(function() {
						container.removeClass('fp-notransition');
					}, 10)
				}

				/**
				 * Scrolls to the given section and slide
				 */
				function scrollPageAndSlide(destiny, slide) {
					if(typeof slide === 'undefined') {
						slide = 0;
					}

					if(isNaN(destiny)) {
						var section = $('[data-anchor="' + destiny + '"]');
					} else {
						var section = $('.fp-section').eq((destiny - 1));
					}

					//we need to scroll to the section and then to the slide
					if(destiny !== lastScrolledDestiny && !section.hasClass('active')) {
						scrollPage(section, function() {
							scrollSlider(section, slide)
						});
					}
					//if we were already in the section
					else {
						scrollSlider(section, slide);
					}
				}

				/**
				 * Scrolls the slider to the given slide destination for the given section
				 */
				function scrollSlider(section, slide) {
					if(typeof slide != 'undefined') {
						var slides = section.find('.fp-slides');
						var destiny = slides.find('[data-anchor="' + slide + '"]');

						if(!destiny.length) {
							destiny = slides.find('.fp-slide').eq(slide);
						}

						if(destiny.length) {
							landscapeScroll(slides, destiny);
						}
					}
				}

				/**
				 * Creates a landscape navigation bar with dots for horizontal sliders.
				 */
				function addSlidesNavigation(section, numSlides) {
					section.append('<div class="fp-slidesNav"><ul></ul></div>');
					var nav = section.find('.fp-slidesNav');

					//top or bottom
					nav.addClass(options.slidesNavPosition);

					for(var i = 0; i < numSlides; i++) {
						nav.find('ul').append('<li><a href="#"><span></span></a></li>');
					}

					//centering it
					nav.css('margin-left', '-' + (nav.width() / 2) + 'px');

					nav.find('li').first().find('a').addClass('active');
				}

				/**
				 * Sets the state of the website depending on the active section/slide.
				 * It changes the URL hash when needed and updates the body class.
				 */
				function setState(slideIndex, slideAnchor, anchorLink, sectionIndex) {
					var sectionHash = '';

					if(options.anchors.length) {

						//isn't it the first slide?
						if(slideIndex) {
							if(typeof anchorLink !== 'undefined') {
								sectionHash = anchorLink;
							}

							//slide without anchor link? We take the index instead.
							if(typeof slideAnchor === 'undefined') {
								slideAnchor = slideIndex;
							}

							lastScrolledSlide = slideAnchor;
							setUrlHash(sectionHash + '/' + slideAnchor);

							//first slide won't have slide anchor, just the section one
						} else if(typeof slideIndex !== 'undefined') {
							lastScrolledSlide = slideAnchor;
							setUrlHash(anchorLink);
						}

						//section without slides
						else {
							setUrlHash(anchorLink);
						}

						setBodyClass(location.hash);
					} else if(typeof slideIndex !== 'undefined') {
						setBodyClass(sectionIndex + '-' + slideIndex);
					} else {
						setBodyClass(String(sectionIndex));
					}
				}

				/**
				 * Sets the URL hash.
				 */
				function setUrlHash(url) {
					if(options.recordHistory) {
						location.hash = url;
					} else {
						//Mobile Chrome doesn't work the normal way, so... lets use HTML5 for phones :)
						if(isTouchDevice || isTouch) {
							history.replaceState(undefined, undefined, "#" + url)
						} else {
							var baseUrl = window.location.href.split('#')[0];
							window.location.replace(baseUrl + '#' + url);
						}
					}
				}

				/**
				 * Sets a class for the body of the page depending on the active section / slide
				 */
				function setBodyClass(text) {
					//changing slash for dash to make it a valid CSS style
					text = text.replace('/', '-').replace('#', '');

					//removing previous anchor classes
					$("body")[0].className = $("body")[0].className.replace(/\b\s?fp-viewing-[^\s]+\b/g, '');

					//adding the current anchor
					$("body").addClass("fp-viewing-" + text);
				}

				/**
				 * Checks for translate3d support
				 * @return boolean
				 * http://stackoverflow.com/questions/5661671/detecting-transform-translate3d-support
				 */
				function support3d() {
					var el = document.createElement('p'),
						has3d,
						transforms = {
							'webkitTransform': '-webkit-transform',
							'OTransform': '-o-transform',
							'msTransform': '-ms-transform',
							'MozTransform': '-moz-transform',
							'transform': 'transform'
						};

					// Add it to the body to get the computed style.
					document.body.insertBefore(el, null);

					for(var t in transforms) {
						if(el.style[t] !== undefined) {
							el.style[t] = "translate3d(1px,1px,1px)";
							has3d = window.getComputedStyle(el).getPropertyValue(transforms[t]);
						}
					}

					document.body.removeChild(el);

					return(has3d !== undefined && has3d.length > 0 && has3d !== "none");
				}

				/**
				 * Removes the auto scrolling action fired by the mouse wheel and trackpad.
				 * After this function is called, the mousewheel and trackpad movements won't scroll through sections.
				 */
				function removeMouseWheelHandler() {
					if(document.addEventListener) {
						document.removeEventListener('mousewheel', MouseWheelHandler, false); //IE9, Chrome, Safari, Oper
						document.removeEventListener('wheel', MouseWheelHandler, false); //Firefox
					} else {
						document.detachEvent("onmousewheel", MouseWheelHandler); //IE 6/7/8
					}
				}

				/**
				 * Adds the auto scrolling action for the mouse wheel and trackpad.
				 * After this function is called, the mousewheel and trackpad movements will scroll through sections
				 */
				function addMouseWheelHandler() {
					if(document.addEventListener) {
						document.addEventListener("mousewheel", MouseWheelHandler, false); //IE9, Chrome, Safari, Oper
						document.addEventListener("wheel", MouseWheelHandler, false); //Firefox
					} else {
						document.attachEvent("onmousewheel", MouseWheelHandler); //IE 6/7/8
					}
				}

				/**
				 * Adds the possibility to auto scroll through sections on touch devices.
				 */
				function addTouchHandler() {
					if(isTouchDevice || isTouch) {
						//Microsoft pointers
						MSPointer = getMSPointer();

						$(document).off('touchstart ' + MSPointer.down).on('touchstart ' + MSPointer.down, touchStartHandler);
//						$(document).off('touchmove ' + MSPointer.move).on('touchmove ' + MSPointer.move, touchMoveHandler);
					}
				}

				/**
				 * Removes the auto scrolling for touch devices.
				 */
				function removeTouchHandler() {
					if(isTouchDevice || isTouch) {
						//Microsoft pointers
						MSPointer = getMSPointer();

						$(document).off('touchstart ' + MSPointer.down);
						$(document).off('touchmove ' + MSPointer.move);
					}
				}

				/*
				 * Returns and object with Microsoft pointers (for IE<11 and for IE >= 11)
				 * http://msdn.microsoft.com/en-us/library/ie/dn304886(v=vs.85).aspx
				 */
				function getMSPointer() {
					var pointer;

					//IE >= 11 & rest of browsers
					if(window.PointerEvent) {
						pointer = {
							down: "pointerdown",
							move: "pointermove"
						};
					}

					//IE < 11
					else {
						pointer = {
							down: "MSPointerDown",
							move: "MSPointerMove"
						};
					}

					return pointer;
				}
				/**
				 * Gets the pageX and pageY properties depending on the browser.
				 * https://github.com/alvarotrigo/fullPage.js/issues/194#issuecomment-34069854
				 */
				function getEventsPage(e) {
					var events = new Array();

					events['y'] = (typeof e.pageY !== 'undefined' && (e.pageY || e.pageX) ? e.pageY : e.touches[0].pageY);
					events['x'] = (typeof e.pageX !== 'undefined' && (e.pageY || e.pageX) ? e.pageX : e.touches[0].pageX);

					return events;
				}

				function silentLandscapeScroll(activeSlide) {
					$.fn.fullpage.setScrollingSpeed(0, 'internal');
					landscapeScroll(activeSlide.closest('.fp-slides'), activeSlide);
					$.fn.fullpage.setScrollingSpeed(originals.scrollingSpeed, 'internal');
				}

				function silentScroll(top) {
					if(options.scrollBar) {
						container.scrollTop(top);
					} else if(options.css3) {
						var translate3d = 'translate3d(0px, -' + top + 'px, 0px)';
						transformContainer(translate3d, false);
					} else {
						container.css("top", -top);
					}
				}

				function getTransforms(translate3d) {
					return {
						'-webkit-transform': translate3d,
						'-moz-transform': translate3d,
						'-ms-transform': translate3d,
						'transform': translate3d
					};
				}

				function setIsScrollable(value, direction) {
					switch(direction) {
						case 'up':
							isScrollAllowed.up = value;
							break;
						case 'down':
							isScrollAllowed.down = value;
							break;
						case 'left':
							isScrollAllowed.left = value;
							break;
						case 'right':
							isScrollAllowed.right = value;
							break;
						case 'all':
							$.fn.fullpage.setAllowScrolling(value);
					}
				}

				/*
				 * Destroys fullpage.js plugin events and optinally its html markup and styles
				 */
				$.fn.fullpage.destroy = function(all) {
					$.fn.fullpage.setAutoScrolling(false, 'internal');
					$.fn.fullpage.setAllowScrolling(false);
					$.fn.fullpage.setKeyboardScrolling(false);

					$(window)
						.off('scroll', scrollHandler)
						.off('hashchange', hashChangeHandler)
						.off('resize', resizeHandler);

					$(document)
						.off('click', '#fp-nav a')
						.off('mouseenter', '#fp-nav li')
						.off('mouseleave', '#fp-nav li')
						.off('click', '.fp-slidesNav a')
						.off('mouseover', options.normalScrollElements)
						.off('mouseout', options.normalScrollElements);

					$('.fp-section')
						.off('click', '.fp-controlArrow');

					//lets make a mess!
					if(all) {
						destroyStructure();
					}
				};

				/*
				 * Removes inline styles added by fullpage.js
				 */
				function destroyStructure() {
					//reseting the `top` or `translate` properties to 0
					silentScroll(0);

					$('#fp-nav, .fp-slidesNav, .fp-controlArrow').remove();

					//removing inline styles
					$('.fp-section').css({
						'height': '',
						'background-color': '',
						'padding': ''
					});

					$('.fp-slide').css({
						'width': ''
					});

					container.css({
						'height': '',
						'position': '',
						'-ms-touch-action': '',
						'touch-action': ''
					});

					//removing added classes
					$('.fp-section, .fp-slide').each(function() {
						removeSlimScroll($(this));
						$(this).removeClass('fp-table active');
					});

					removeAnimation(container);
					removeAnimation(container.find('.fp-easing'));

					//Unwrapping content
					container.find('.fp-tableCell, .fp-slidesContainer, .fp-slides').each(function() {
						//unwrap not being use in case there's no child element inside and its just text
						$(this).replaceWith(this.childNodes);
					});

					//scrolling the page to the top with no animation
					$('html, body').scrollTop(0);
				}

				/*
				 * Sets the state for a variable with multiple states (original, and temporal)
				 * Some variables such as `autoScrolling` or `recordHistory` might change automatically its state when using `responsive` or `autoScrolling:false`.
				 * This function is used to keep track of both states, the original and the temporal one.
				 * If type is not 'internal', then we assume the user is globally changing the variable.
				 */
				function setVariableState(variable, value, type) {
					options[variable] = value;
					if(type !== 'internal') {
						originals[variable] = value;
					}
				}

				/**
				 * Displays warnings
				 */
				function displayWarnings() {
					// Disable mutually exclusive settings
					if(options.continuousVertical &&
						(options.loopTop || options.loopBottom)) {
						options.continuousVertical = false;
						showError('warn', "Option `loopTop/loopBottom` is mutually exclusive with `continuousVertical`; `continuousVertical` disabled");
					}
					if(options.continuousVertical && options.scrollBar) {
						options.continuousVertical = false;
						showError('warn', "Option `scrollBar` is mutually exclusive with `continuousVertical`; `continuousVertical` disabled");
					}

					//anchors can not have the same value as any element ID or NAME
					$.each(options.anchors, function(index, name) {
						if($('#' + name).length || $('[name="' + name + '"]').length) {
							showError('error', "data-anchor tags can not have the same value as any `id` element on the site (or `name` element for IE).");
						}
					});
				}

				function showError(type, text) {
					console && console[type] && console[type]('fullPage: ' + text);
				}
			};
		})(jQuery);

	})(jQuery);
	layui.link(basePath + '../../lib/layui/lay/modules/fullscreenslider/ddfullscreenslider.css');
	exports('fullscreenslider', null);
});